{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:38.881242Z",
     "start_time": "2025-01-09T12:10:37.638780Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:38.927099Z",
     "start_time": "2025-01-09T12:10:38.900386Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:39.226217Z",
     "start_time": "2025-01-09T12:10:39.211129Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:39.258162Z",
     "start_time": "2025-01-09T12:10:39.239260Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:36:17.203806Z",
     "start_time": "2025-01-09T12:36:17.179736Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:39.995023Z",
     "start_time": "2025-01-09T12:10:39.965584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.026171Z",
     "start_time": "2025-01-09T12:10:40.013129Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "source": [
    "(1-60)/30"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.071955Z",
     "start_time": "2025-01-09T12:10:40.051870Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)#均值\n",
    "    print('-' * 50)\n",
    "    print(std.var_)#方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.134984Z",
     "start_time": "2025-01-09T12:10:40.114114Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.165508Z",
     "start_time": "2025-01-09T12:10:40.160508Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.228686Z",
     "start_time": "2025-01-09T12:10:40.217175Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.259619Z",
     "start_time": "2025-01-09T12:10:40.253390Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5555556666666668"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.306555Z",
     "start_time": "2025-01-09T12:10:40.293201Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.068779614944516"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean,median,most_frequent(众数),constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.337547Z",
     "start_time": "2025-01-09T12:10:40.323775Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": [
    "11/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.383338Z",
     "start_time": "2025-01-09T12:10:40.370309Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "np.nan+10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.415462Z",
     "start_time": "2025-01-09T12:10:40.402423Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.447063Z",
     "start_time": "2025-01-09T12:10:40.435525Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.494130Z",
     "start_time": "2025-01-09T12:10:40.470565Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[ 1.28620952e-15  3.82970843e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "source": [
    "22/29.333333333333336"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:40.526212Z",
     "start_time": "2025-01-09T12:10:40.512188Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T12:10:41.231104Z",
     "start_time": "2025-01-09T12:10:40.560520Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 21
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
